package org.linearlist;

/**
 * @author: 默苍璃
 * @date: 2023-04-04 15:26
 * <p>
 * 线性表 的 顺序 表示和实现
 */
public class SequenceList<T> {

    /**
     * 顺序表中一维数组的初始长度
     */
    final int maxSize = 10;

    /**
     * 存储元素的数组对象
     */
    private T[] listArray;

    /**
     * 保存顺序表的当前长度
     */
    private int length;


    /**
     * 构造一个空的线性表
     */
    public SequenceList() {
        //线性表初始为空
        length = 0;
        listArray = (T[]) new Object[maxSize];
    }

    public SequenceList(int n) {
        if (n < 0) {
            System.out.println("error");
            System.exit(1);
        }

        //线性表初始为空
        length = 0;
        listArray = (T[]) new Object[n];
    }


    /**
     * 在线性表中插入一个新元素
     *
     * @param obj
     * @param pos
     * @return
     */
    public boolean add(T obj, int pos) {
        if (pos < 1 || pos > length + 1) {
            System.out.println("pos值不合法");
            return false;
        }

        //判断空间是否已满
        if (length == listArray.length) {
            T[] p = (T[]) new Object[length * 2];
            for (int i = 0; i < length; i++) {
                p[i] = listArray[i];
            }
            listArray = p;
        }

        for (int i = length; i >= pos; i--) {
            listArray[i] = listArray[i - 1];
        }
        listArray[pos - 1] = obj;
        //顺序表的长度加1
        length++;
        return true;
    }


    /**
     * 删除线性表中某个元素
     *
     * @param pos
     * @return
     */
    public T remove(int pos) {
        if (isEmpty()) {
            System.out.println("顺序表为空，无法执行删除操作");
            return null;
        } else {
            if (pos < 1 || pos > length) {
                System.out.println("pos值不合法");
                return null;
            }
            T x = listArray[pos - 1];
            for (int i = pos; i <= length; i++) {
                listArray[i - 1] = listArray[i];
            }
            length--;
            return x;
        }
    }


    /**
     * 在线性表查找一个元素
     *
     * @param obj
     * @return
     */
    public int find(T obj) {
        if (isEmpty()) {
            System.out.println("顺序表为空");
        } else {
            for (int i = 0; i < length; i++) {
                if (listArray[i].equals(obj)) {
                    return i + 1;
                }
            }
        }
        return -1;
    }


    /**
     * 获取线性表中一个元素
     *
     * @param pos
     * @return
     */
    public T value(int pos) {
        if (isEmpty()) {
            System.out.println("顺序表为空");
            return null;
        } else {
            if (pos < 1 || pos > length) {
                System.out.println("pos值不合法");
                return null;
            }
            return listArray[pos - 1];
        }
    }


    /**
     * 更新线性表中某个元素
     *
     * @param obj
     * @param pos
     * @return
     */
    public boolean modify(T obj, int pos) {
        if (isEmpty()) {
            System.out.println("顺序表为空");
            return false;
        } else {
            if (pos < 1 || pos > length) {
                System.out.println("error");
                return false;
            }
            listArray[pos - 1] = obj;
            return true;
        }
    }


    /**
     * 判空
     *
     * @return
     */
    public boolean isEmpty() {
        return length == 0;
    }


    /**
     * 求线性表中数据元素的个数
     *
     * @return
     */
    public int size() {
        return length;
    }


    /**
     * 依次访问栈中每个元素并输出
     */
    public void nextOrder() {
        for (int i = 0; i < length; i++) {
            System.out.println(listArray[i]);
        }
    }


    /**
     * 销毁一个已经存在的线性表
     */
    public void clear() {
        length = 0;
    }


}
